home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 4 / Amiga Tools 4.iso / tools / netzwerk / tcp-ip / ipdial_v1.9 / serial.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-26  |  16.8 KB  |  749 lines
  1. /**
  2. ***  IPDial     Script program for initializing a SLIP connection
  3. ***  Copyright  (C)   1994    Jochen Wiedmann
  4. ***
  5. ***  This program is free software; you can redistribute it and/or modify
  6. ***  it under the terms of the GNU General Public License as published by
  7. ***  the Free Software Foundation; either version 2 of the License, or
  8. ***  (at your option) any later version.
  9. ***
  10. ***  This program is distributed in the hope that it will be useful,
  11. ***  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. ***  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. ***  GNU General Public License for more details.
  14. ***
  15. ***  You should have received a copy of the GNU General Public License
  16. ***  along with this program; if not, write to the Free Software
  17. ***  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. ***
  19. ***
  20. ***
  21. ***  This file implements the communication with the serial.device.
  22. ***
  23. ***
  24. ***  Computer: Amiga 1200                       Compiler: Dice 3.01
  25. ***
  26. ***  Author:    Jochen Wiedmann
  27. ***             Am Eisteich 9
  28. ***             72555 Metzingen
  29. ***             Germany
  30. ***
  31. ***             Phone: (+0049) 7123 / 14881
  32. ***             Internet: wiedmann@neckar-alb.de
  33. **/
  34.  
  35. /**
  36. ***  Include files
  37. **/
  38. #ifndef IPDIAL_H
  39. #include "IPDial.h"
  40. #endif
  41. #include <ctype.h>
  42. #include <devices/serial.h>
  43. #include <devices/timer.h>
  44.  
  45. #ifndef MIN
  46. #define MIN(a,b) (((a)>(b))?(b):(a))
  47. #endif
  48.  
  49. /**
  50. ***  Local variables.
  51. **/
  52. STATIC APTR MySerReq            = NULL;
  53. STATIC APTR MyTimeReq           = NULL;
  54. STATIC UBYTE SerBuffer[4096];
  55.  
  56. /**
  57. ***  Cleanup function.
  58. **/
  59. VOID SerialCleanup(VOID)
  60. { 
  61.   DeviceIODelete(MySerReq);
  62.   DeviceIODelete(MyTimeReq);
  63. }
  64.  
  65. /**
  66. ***  Table of error messages created by the serial.device.
  67. **/
  68. STATIC VOID SerialShowError(ULONG Error)
  69. { 
  70.   STRPTR ptr;
  71.  
  72.   switch(Error)
  73.   { case 1:
  74.       ptr = (STRPTR) "Serial device busy";
  75.       break;
  76.     case 2:
  77.       ptr = (STRPTR) "Baud rate not supported";
  78.       break;
  79.     case 4:
  80.       ptr = (STRPTR) "Memory error";
  81.       break;
  82.     case 5:
  83.       ptr = (STRPTR) "Invalid parameters";
  84.       break;
  85.     case 6:
  86.       ptr = (STRPTR) "Line error";
  87.       break;
  88.     case 9:
  89.       ptr = (STRPTR) "Parity error";
  90.       break;
  91.     case 11:
  92.       ptr = (STRPTR) "Timer error";
  93.       break;
  94.     case 12:
  95.       ptr = (STRPTR) "Buffer overflow";
  96.       break;
  97.     case 13:
  98.       ptr = (STRPTR) "No DSR";
  99.       break;
  100.     case 15:
  101.       ptr = (STRPTR) "Break detected";
  102.       break;
  103.     default:
  104.       ptr = (STRPTR) "Unknown error";
  105.       break;
  106.   }
  107.  
  108.   fprintf(stderr, "Serial device: %s.\n", ptr);
  109. }
  110.  
  111. /**
  112. ***  This function opens the serial device. It can be closed
  113. ***  using DeviceIODelete().
  114. **/
  115. STATIC ULONG SerialDecodeProtocol(struct IOExtSer *SerReq, STRPTR Protocol)
  116.  
  117. { 
  118.   if (VerboseMode)
  119.     printf("\nSerialDecodeProtocol: Protocol %s\n", Protocol);
  120.  
  121.   if (stricmp((char *) Protocol, "XONXOFF") == 0)
  122.   { 
  123.     if (VerboseMode)
  124.       printf("SerialDecodeProtocol: Setting XON/XOFF\n");
  125.       
  126.     SerReq->io_SerFlags &= ~(SERF_XDISABLED|SERF_7WIRE);
  127.   }
  128.   else if (stricmp((char *) Protocol, "NONE") == 0)
  129.   { 
  130.     if (VerboseMode)
  131.       printf("SerialDecodeProtocol: Setting NONE\n");
  132.       
  133.     SerReq->io_SerFlags |= SERF_XDISABLED;
  134.     SerReq->io_SerFlags &= ~SERF_7WIRE;
  135.   }
  136.   else if (stricmp((char *) Protocol, "RTSCTS") == 0  ||
  137.              stricmp((char *) Protocol, "7WIRE") == 0)
  138.   { 
  139.     if (VerboseMode)
  140.       printf("SerialDecodeProtocol: Setting RTS/CTS and 7WIRE\n");
  141.       
  142.     SerReq->io_SerFlags |= (SERF_XDISABLED|SERF_7WIRE);
  143.   }
  144.   else
  145.   { 
  146.     if (VerboseMode)
  147.       printf("SerialDecodeProtocol: Unknown Protocol: %s\n", Protocol);
  148.       
  149.     return(FALSE);
  150.   }
  151.   return(TRUE);
  152. }
  153.  
  154. ULONG SerialOpen(STRPTR DeviceName, STRPTR Protocol, ULONG Unit)
  155. { 
  156.   ULONG error;
  157.   struct IOExtSer *RealSerReq;
  158.  
  159.   if (VerboseMode)
  160.     printf("\nSerialOpen: Device Name %s Protocol %s\n", DeviceName, Protocol);
  161.     
  162.   if (!(MySerReq = DeviceIOCreate(sizeof(struct IOExtSer))))
  163.   { 
  164.     fprintf(stderr, "Failed to open %s: Memory error.\n",
  165.         DeviceName);
  166.     exit(10);
  167.   }
  168.   RealSerReq = (struct IOExtSer *) DeviceIOReq(MySerReq);
  169.   RealSerReq->io_SerFlags = 0;
  170.   if (Protocol)
  171.   { 
  172.     if (!SerialDecodeProtocol(RealSerReq, Protocol))
  173.     { 
  174.       return(FALSE);
  175.     }
  176.   }
  177.   if ((error = DeviceIOOpen(DeviceName, Unit, MySerReq, 0)))
  178.   { 
  179.     SerialShowError(error);
  180.     exit(10);
  181.   }
  182.   if (Protocol)
  183.   { 
  184.     SerialSetProtocol(Protocol);
  185.   }
  186.  
  187.   if (!(MyTimeReq = DeviceIOCreate(sizeof(struct timerequest))))
  188.   { 
  189.     fprintf(stderr, "Failed to open timer.device: Memory error.\n");
  190.     exit(10);
  191.   }
  192.   if ((error = DeviceIOOpen((STRPTR) "timer.device", UNIT_VBLANK,
  193.                                     MyTimeReq, 0)))
  194.   { 
  195.     fprintf(stderr, "Failed to open timer.device: Error %ld\n", error);
  196.     exit(10);
  197.   }
  198.   return(TRUE);
  199. }
  200.  
  201. /**
  202. ***  This function sends a string to the serial device.
  203. **/
  204. VOID SerialSend(STRPTR str, ULONG len)
  205.  
  206. { 
  207.   struct IOExtSer *req;
  208.  
  209.   if (VerboseMode)
  210.     printf("\nSerialSend: %s\n", str);
  211.  
  212.   req = (struct IOExtSer *) DeviceIOReq(MySerReq);
  213.   req->IOSer.io_Length = strlen((char*) str);
  214.   req->IOSer.io_Data = str;
  215.   DeviceIODo(MySerReq, CMD_WRITE);
  216. }
  217.  
  218. /**
  219. ***  This function is used to wait for a certain string.
  220. ***
  221. ***  The function will return if either a timeout occurs
  222. ***  (never happens, if timeout == -1) or if one of the
  223. ***  strings in the args array is read from the serial.device.
  224. ***
  225. ***  Result is the number of the string or -1.
  226. **/
  227. STATIC APTR waitBuffer = NULL;
  228. LONG SerialWait(STRPTR *args, LONG timeout)
  229. { 
  230.   ULONG sigs;
  231.   ULONG rsigs;
  232.   BYTE error;
  233.   struct IOExtSer *SerReq;
  234.   
  235.   if(VerboseMode)
  236.   {
  237.     int i=0;
  238.     printf("SerialWait: timeout = %d\n",timeout);
  239.     while(args[i])
  240.     {
  241.       printf("SerialWait: args[%d] %s \n",i,args[i]);
  242.       i++;
  243.     }
  244.   }
  245.   SerReq = (struct IOExtSer *) DeviceIOReq(MySerReq);
  246.  
  247.   /**
  248.   ***  Be sure, that the buffer is valid.
  249.   **/
  250.   if (!waitBuffer  &&  !(waitBuffer = BufferCreate()))
  251.   { 
  252.     perror("malloc");
  253.     exit(10);
  254.   }
  255.  
  256.   /**
  257.   ***  Clear the buffer.
  258.   **/
  259.   BufferClear(waitBuffer);
  260.  
  261.   sigs = SIGBREAKF_CTRL_C | DeviceIOSignal(MySerReq);
  262.  
  263.   if (timeout != -1)
  264.   { 
  265.     struct timerequest *tr = (struct timerequest *) DeviceIOReq(MyTimeReq);
  266.  
  267.     tr->tr_time.tv_secs = timeout;
  268.     tr->tr_time.tv_micro = 0;
  269.     DeviceIOSend(MyTimeReq, TR_ADDREQUEST);
  270.     sigs |= DeviceIOSignal(MyTimeReq);
  271.   }
  272.  
  273.   for(;;)
  274.   { 
  275.     LONG result;
  276.  
  277.     /**
  278.     ***  First ask, if any data is present on the serial line.
  279.     ***  May be, the string we are waiting for is already present?
  280.     **/
  281.     do
  282.     { 
  283.       DeviceIODo(MySerReq, SDCMD_QUERY);
  284.       if ((result = SerReq->IOSer.io_Actual))
  285.       { 
  286.         SerReq->IOSer.io_Data = SerBuffer;
  287.           SerReq->IOSer.io_Length = MIN(sizeof(SerBuffer)-1, 
  288.                                   SerReq->IOSer.io_Actual);
  289.         if ((error = DeviceIODo(MySerReq, CMD_READ)))
  290.           { 
  291.           SerialShowError(error);
  292.             exit(10);
  293.           }
  294.           if (EchoMode)
  295.           { 
  296.           int i;
  297.  
  298.             for (i = 0;  i < SerReq->IOSer.io_Actual;  i++)
  299.             { 
  300.             putchar(SerBuffer[i]);
  301.             }
  302.             fflush(stdout);
  303.           }
  304.           BufferExtend(waitBuffer, SerBuffer, SerReq->IOSer.io_Actual);
  305.       }
  306.     }
  307.     while (result);
  308.  
  309.  
  310.     if ((result = BufferCheck(waitBuffer, args)) >= 0)
  311.     { 
  312.       DeviceIOAbort(MyTimeReq);
  313.       if(VerboseMode)
  314.         printf("SerialWait: Exit line %d result = %d\n",__LINE__,result);
  315.        return(result);
  316.     }
  317.  
  318.     /**
  319.     ***  It isn't, send a request for one byte.
  320.     **/
  321.     SerReq->IOSer.io_Length = 1;
  322.     SerReq->IOSer.io_Data = SerBuffer;
  323.     DeviceIOSend(MySerReq, CMD_READ);
  324.  
  325.     rsigs = Wait(sigs);
  326.  
  327.     if (rsigs & SIGBREAKF_CTRL_C)
  328.     { 
  329.       printf("Ctrl-C\n");
  330.       exit(10);
  331.     }
  332.     else if (rsigs & DeviceIOSignal(MySerReq))
  333.     { 
  334.       BYTE error;
  335.  
  336.       /**
  337.       ***  Data received, add it to the buffer and check for more.
  338.       **/
  339.       if ((error = DeviceIOWait(MySerReq)))
  340.       { 
  341.         SerialShowError(error);
  342.           exit(10);
  343.       }
  344.       if (EchoMode)
  345.       { 
  346.         putchar(*SerBuffer);
  347.           fflush(stdout);
  348.       }
  349.       BufferExtend(waitBuffer, SerBuffer, 1);
  350.     }
  351.     else
  352.     { /**
  353.       ***  Timeout
  354.       **/
  355.       DeviceIOWait(MyTimeReq);
  356.       DeviceIOAbort(MySerReq);
  357.       if(VerboseMode)
  358.         printf("SerialWait: Timeout Exit line %d\n",__LINE__);
  359.       return(-1);
  360.     }
  361.   }
  362.   if(VerboseMode)
  363.     printf("SerialWait: Exit line %d\n",__LINE__);
  364. }
  365. /**
  366. ***  Return buffer read by the last "Wait" command.
  367. **/
  368. STRPTR SerialWaitBuffer(VOID)
  369. { if (!(waitBuffer))
  370.   { 
  371.     return((STRPTR) "");
  372.   }
  373.   else
  374.   { 
  375.     return(BufferBuffer(waitBuffer));
  376.   }
  377. }
  378. /**
  379. ***  This function implements a terminal mode. It gives the users input
  380. ***  to the modem and likewise the modems output to the user, as long as
  381. ***  the user doesn't enter Ctrl-\.
  382. **/
  383. VOID SerialTerminal(STRPTR eof, ULONG echo, ULONG lineMode)
  384. { 
  385.   struct DosPacket *dp;
  386.   struct MsgPort *port = NULL;
  387.   struct IOExtSer *SerReq = (struct IOExtSer *) DeviceIOReq(MySerReq);
  388.                             APTR SerSendReq = NULL;
  389.   struct IOExtSer *serSendReq;
  390.   char   buffer[128];
  391.   char   sendBuffer[256]; /* Twice the size of buffer */
  392.   ULONG  bufSize = sizeof(buffer);
  393.   ULONG  status = 10;
  394.   BPTR   cis = Input();
  395.   ULONG  sigs;
  396.  
  397.   if (!cis)
  398.   { 
  399.     fprintf(stderr, "Can't use nil: as input device.\n");
  400.     exit(10);
  401.   }
  402.  
  403.   if (!echo) 
  404.   {
  405.     lineMode = FALSE;
  406.   }
  407.   if (!lineMode) 
  408.   {
  409.     if (!SetMode(cis, TRUE)) 
  410.     {
  411.         fprintf(stderr, "Can't put console into character (raw) mode.\n");
  412.         exit(10);
  413.     }
  414.     bufSize = 128;
  415.   }
  416.  
  417.  
  418.   if ((dp = AllocDosObject(DOS_STDPKT, NULL)))
  419.   { if ((port = CreateMsgPort()))
  420.     { if ((SerSendReq = DeviceIOCreate(sizeof(struct IOExtSer))))
  421.       { 
  422.         serSendReq = (struct IOExtSer *) DeviceIOReq(SerSendReq);
  423.           serSendReq->IOSer.io_Device = SerReq->IOSer.io_Device;
  424.           serSendReq->IOSer.io_Unit = SerReq->IOSer.io_Unit;
  425.           status = 0;
  426.       }
  427.     }
  428.   }
  429.  
  430.   if (status)
  431.   { 
  432.     fprintf(stderr, "Memory error.\n");
  433.     goto ExitSerialTerminal;
  434.   }
  435.  
  436.   dp->dp_Type = ACTION_READ;
  437.   dp->dp_Arg1 = ((struct FileHandle *) BADDR(cis))->fh_Arg1;
  438.   dp->dp_Arg2 = (ULONG) buffer;
  439.   dp->dp_Arg3 = bufSize;
  440.   SendPkt(dp, (struct MsgPort *) ((struct FileHandle *) BADDR(cis))->fh_Type, 
  441.           port);
  442.  
  443.   SerReq->IOSer.io_Length = 1;
  444.   SerReq->IOSer.io_Data = SerBuffer;
  445.   DeviceIOSend(MySerReq, CMD_READ);
  446.  
  447.   sigs = (1 << port->mp_SigBit) | SIGBREAKF_CTRL_C | DeviceIOSignal(MySerReq);
  448.  
  449.   for(;;)
  450.   { 
  451.     LONG rsigs;
  452.     rsigs = Wait(sigs);
  453.     if (rsigs & SIGBREAKF_CTRL_C)
  454.     { 
  455.       fprintf(stderr, "Ctrl-C\n");
  456.       status = 5;
  457.       DeviceIOAbort(MySerReq);
  458.       AbortPkt(port, dp);
  459.       WaitPort(port);
  460.       goto ExitSerialTerminal;
  461.     }
  462.  
  463.     if (rsigs & (1 << port->mp_SigBit))
  464.     { int eofSeen = FALSE;
  465.       GetMsg(port);
  466.       if (dp->dp_Res1 == -1)
  467.       { 
  468.         fprintf(stderr, "Error %ld while reading input.\n", dp->dp_Res2);
  469.           status = 10;
  470.       }
  471.       if (dp->dp_Res1 == 0)
  472.       { 
  473.         eofSeen = TRUE;
  474.       }
  475.       else
  476.       { 
  477.         int i, bufLen;  /*  Extend LF to CR/LF and send resulting string.   */
  478.         bufLen = 0;
  479.           for (i = 0;  i < dp->dp_Res1;  i++)
  480.           { 
  481.           if ((eof  &&  *eof == buffer[i])  ||
  482.                 (!eof  &&  !lineMode  &&  buffer[i] == 0x1c))
  483.             { 
  484.              eofSeen = TRUE;
  485.             }
  486.             if (lineMode  &&  buffer[i] == '\n')
  487.             { 
  488.             sendBuffer[bufLen++] = '\r';
  489.               sendBuffer[bufLen++] = '\n';
  490.             }
  491.             else
  492.             { 
  493.             sendBuffer[bufLen++] = buffer[i];
  494.             }
  495.           }
  496.  
  497.           if (bufLen > 0)
  498.           { 
  499.           serSendReq->IOSer.io_Length = bufLen;
  500.             serSendReq->IOSer.io_Data = sendBuffer;
  501.             DeviceIODo(SerSendReq, CMD_WRITE);
  502.           }
  503.  
  504.           if (!lineMode  &&  echo)
  505.           { 
  506.           fwrite(sendBuffer, bufLen, 1, stdout);
  507.             fflush(stdout);
  508.           }
  509.       }
  510.  
  511.       if (eofSeen)
  512.       { 
  513.         DeviceIOAbort(MySerReq);
  514.         goto ExitSerialTerminal;
  515.       }
  516.       dp->dp_Type = ACTION_READ;
  517.       dp->dp_Arg1 = ((struct FileHandle *) BADDR(cis))->fh_Arg1;
  518.       dp->dp_Arg2 = (ULONG) buffer;
  519.       dp->dp_Arg3 = bufSize;
  520.       SendPkt(dp, (struct MsgPort *) ((struct FileHandle *) BADDR(cis))->fh_Type, port);
  521.     }
  522.  
  523.     if (rsigs & DeviceIOSignal(MySerReq))
  524.     { 
  525.       LONG error;
  526.       LONG result;
  527.  
  528.       if ((error = DeviceIOWait(MySerReq)))
  529.       { 
  530.         SerialShowError(error);
  531.         AbortPkt(port, dp);
  532.           WaitPort(port);
  533.           goto ExitSerialTerminal;
  534.       }
  535.       putchar(*SerBuffer);
  536.       fflush(stdout);
  537.  
  538.       do
  539.       { 
  540.         DeviceIODo(MySerReq, SDCMD_QUERY);
  541.           if ((result = SerReq->IOSer.io_Actual))
  542.           { 
  543.           SerReq->IOSer.io_Data = SerBuffer;
  544.             SerReq->IOSer.io_Length = MIN(sizeof(SerBuffer)-1, 
  545.                                     SerReq->IOSer.io_Actual);
  546.             if ((error = DeviceIODo(MySerReq, CMD_READ)))
  547.             { 
  548.             SerialShowError(error);
  549.               exit(10);
  550.             }
  551.             fwrite(SerBuffer, SerReq->IOSer.io_Actual, 1, stdout);
  552.             fflush(stdout);
  553.           }
  554.       }
  555.       while (result);
  556.  
  557.       SerReq->IOSer.io_Length = 1;
  558.       SerReq->IOSer.io_Data = SerBuffer;
  559.       DeviceIOSend(MySerReq, CMD_READ);
  560.     }
  561.   }
  562.  
  563.  
  564. ExitSerialTerminal:
  565.   if (dp)
  566.   { 
  567.     FreeDosObject(DOS_STDPKT, dp);
  568.   }
  569.   if (port)
  570.   { 
  571.     DeleteMsgPort(port);
  572.   }
  573.   if (SerSendReq)
  574.   { 
  575.     DeviceIODelete(SerSendReq);
  576.   }
  577.   if (!lineMode)
  578.   { 
  579.     SetMode(cis, FALSE);
  580.   }
  581.   if (status)
  582.   { 
  583.     exit(status);
  584.   }
  585. }
  586. /**
  587. ***  This function shows the current serial parameters.
  588. **/
  589. VOID SerialShowParms(VOID)
  590. { 
  591.   STRPTR Parity, Protocol;
  592.   struct IOExtSer *SerReq;
  593.   
  594.   if (VerboseMode)
  595.     printf("\nSerialShowParms\n");
  596.     
  597.   SerReq = (struct IOExtSer *) DeviceIOReq(MySerReq);
  598.  
  599.   printf("\tBaud = %ld\n", SerReq->io_Baud);
  600.   printf("\tDataBits = %ld\n", (ULONG) SerReq->io_ReadLen);
  601.   printf("\tStopBits = %ld\n", (ULONG) SerReq->io_StopBits);
  602.   printf("\tBufSize = %ld\n", SerReq->io_RBufLen);
  603.   if (SerReq->io_SerFlags & SERF_PARTY_ON)
  604.   { 
  605.     if (SerReq->io_SerFlags & SERF_PARTY_ODD)
  606.     { 
  607.       Parity = (STRPTR) "Odd";
  608.     }
  609.     else
  610.     { 
  611.       Parity = (STRPTR) "Even";
  612.     }
  613.   }
  614.   else
  615.   { 
  616.     Parity = (STRPTR) "None";
  617.   }
  618.   printf("\tParity = %s\n", Parity);
  619.   if (SerReq->io_SerFlags & SERF_7WIRE)
  620.   { 
  621.     if (SerReq->io_SerFlags & SERF_XDISABLED)
  622.     { 
  623.       Protocol = (STRPTR) "RTS/CTS";
  624.     }
  625.     else
  626.     { 
  627.       Protocol = (STRPTR) "RTS/CTS, XON/XOFF";
  628.     }
  629.   }
  630.   else
  631.   { 
  632.     if (SerReq->io_SerFlags & SERF_XDISABLED)
  633.     { 
  634.       Protocol = (STRPTR) "None";
  635.     }
  636.     else
  637.     { 
  638.       Protocol = (STRPTR) "XON/XOFF";
  639.     }
  640.   }
  641.   printf("\tProtocol = %s\n\n", Protocol);
  642. }
  643.  
  644. /**
  645. ***  Some functions for setting serial parameters.
  646. **/
  647. VOID SerialSetBaud(ULONG Baud)
  648. { 
  649.   struct IOExtSer *SerReq;
  650.   BYTE   error;
  651.   
  652.   if (VerboseMode)
  653.     printf("\nSerialSetBaud: %d\n", Baud);
  654.     
  655.   SerReq = (struct IOExtSer *) DeviceIOReq(MySerReq);
  656.  
  657.   SerReq->io_Baud = Baud;
  658.   if ((error = DeviceIODo(MySerReq, SDCMD_SETPARAMS)))
  659.   { 
  660.     SerialShowError(error);
  661.     exit(10);
  662.   }
  663. }
  664. VOID SerialSetDataBits(UBYTE DataBits)
  665.  
  666. { struct IOExtSer *SerReq = (struct IOExtSer *) DeviceIOReq(MySerReq);
  667.   BYTE error;
  668.  
  669.   SerReq->io_ReadLen = SerReq->io_WriteLen = DataBits;
  670.   if ((error = DeviceIODo(MySerReq, SDCMD_SETPARAMS)))
  671.   { SerialShowError(error);
  672.     exit(10);
  673.   }
  674. }
  675. VOID SerialSetStopBits(UBYTE StopBits)
  676.  
  677. { struct IOExtSer *SerReq = (struct IOExtSer *) DeviceIOReq(MySerReq);
  678.   BYTE error;
  679.  
  680.   SerReq->io_StopBits = StopBits;
  681.   if ((error = DeviceIODo(MySerReq, SDCMD_SETPARAMS)))
  682.   { SerialShowError(error);
  683.     exit(10);
  684.   }
  685. }
  686. VOID SerialSetBufSize(ULONG BufSize)
  687.  
  688. { struct IOExtSer *SerReq = (struct IOExtSer *) DeviceIOReq(MySerReq);
  689.   BYTE error;
  690.  
  691.   if (BufSize & 0x3f)
  692.   { fprintf(stderr,
  693.         "Warning: BufSize must be a multiple of 64, rounding up.\n");
  694.     BufSize = (BufSize & 0x3f) + 0x40;
  695.   }
  696.   SerReq->io_RBufLen = BufSize;
  697.   if ((error = DeviceIODo(MySerReq, SDCMD_SETPARAMS)))
  698.   { SerialShowError(error);
  699.     exit(10);
  700.   }
  701. }
  702. ULONG SerialSetParity(STRPTR Parity)
  703.  
  704. { struct IOExtSer *SerReq = (struct IOExtSer *) DeviceIOReq(MySerReq);
  705.   BYTE error;
  706.  
  707.   if (stricmp((char *) Parity, "NONE") == 0)
  708.   { SerReq->io_SerFlags &= ~SERF_PARTY_ON;
  709.   }
  710.   else if (stricmp((char *) Parity, "EVEN") == 0)
  711.   { SerReq->io_SerFlags |= SERF_PARTY_ON;
  712.     SerReq->io_SerFlags &= ~SERF_PARTY_ODD;
  713.   }
  714.   else if (stricmp((char *) Parity, "ODD") == 0)
  715.   { SerReq->io_SerFlags |= (SERF_PARTY_ON|SERF_PARTY_ODD);
  716.   }
  717.   else
  718.   { return(FALSE);
  719.   }
  720.  
  721.   if ((error = DeviceIODo(MySerReq, SDCMD_SETPARAMS)))
  722.   { SerialShowError(error);
  723.     exit(10);
  724.   }
  725.   return(TRUE);
  726. }
  727. ULONG SerialSetProtocol(STRPTR Protocol)
  728. { 
  729.   struct IOExtSer *SerReq;
  730.   BYTE error;
  731.   
  732.   if (VerboseMode)
  733.     printf("\nSerialSetProtocol: %s\n", Protocol);
  734.     
  735.   SerReq = (struct IOExtSer *) DeviceIOReq(MySerReq);
  736.  
  737.   if (!(SerialDecodeProtocol(SerReq, Protocol)))
  738.   { 
  739.     return(FALSE);
  740.   }
  741.  
  742.   if ((error = DeviceIODo(MySerReq, SDCMD_SETPARAMS)))
  743.   { 
  744.     SerialShowError(error);
  745.     exit(10);
  746.   }
  747.   return(TRUE);
  748. }
  749.